home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / ATUtilities.lha / ATUtilities / ARexx.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-26  |  24.0 KB  |  1,014 lines
  1. /* ******************************************************************* */
  2. /* **                                                               ** */
  3. /* **                     ATKeyboard Version 4.0                    ** */
  4. /* **            Copright (C) 1992-1994 by Thomas Dreibholz         ** */
  5. /* **                       All rights reserved                     ** */
  6. /* **                                                               ** */
  7. /* **                         ARexx-Verwaltung                      ** */
  8. /* **                                                               ** */
  9. /* ******************************************************************* */
  10.  
  11. #include "ATKeyboard.h"
  12. #include "ATUtilities.h"
  13.  
  14. #define xRMBTRAP (0xffffffff-RMBTRAP)
  15.  
  16. extern struct Einstellungen  Einstellungen;
  17.  
  18. extern struct Einstellungen *Prefs;
  19. UBYTE                        PrefsOK;
  20.  
  21. struct FileHandle       *RWindow;
  22. struct RexxMsg          *rexx;
  23. BOOL                     output;
  24. UBYTE                   *Titel,*MLTitel;
  25. UBYTE                    ARexxTitel[70];
  26.  
  27. extern struct Process   *MainTask;
  28. extern struct Window    *WindowPtr;
  29. extern struct Menu       Menu1;
  30. extern struct ExecBase  *SysBase;
  31. extern struct IOClipReq *ClipReq;
  32. EXTERN UBYTE            *TitelText,Drucker,Papier,Cache;
  33. EXTERN UBYTE            *PapierStat[],*DruckerStat[],*CacheStat[];
  34. EXTERN UBYTE             ATKeyboardVersion,ATKeyboardRevision;
  35. EXTERN LONG              KickstartVersion;
  36. EXTERN LONG              ClipDev;
  37. EXTERN ULONG             transfer;
  38. EXTERN BOOL              Online,LPT1,Service,Clock;
  39. EXTERN BOOL              Schoner;
  40. EXTERN UBYTE             MKAuf[];
  41. EXTERN UBYTE             MKZu[];
  42. EXTERN UBYTE             IKAuf[];
  43. EXTERN UBYTE             IKZu[];
  44. EXTERN UBYTE             ARexxLock;
  45. EXTERN UBYTE             ARexxMenuLock;
  46.  
  47. EXTERN UBYTE *HiFiPort;
  48.  
  49. VOID RW();
  50. VOID OW();
  51. VOID SendeZeichen();
  52. VOID SendeDatei();
  53. VOID SendeClip();
  54.  
  55.  
  56. /* ARexx-Befehlsverarbeitung */
  57. VOID HandleRexxMsg(rm,bool)
  58.  struct RexxMsg *rm;
  59.  BOOL            bool;
  60. {
  61.  REGISTER UBYTE *t;
  62.  REGISTER LONG   Res1,Res2;
  63.  REGISTER LONG   i,j,CmdCount,Pos;
  64.  UBYTE           Command[10][50];
  65.  UBYTE           buffer[24];
  66.  UBYTE           c;
  67.  register struct FileHandle *fh;
  68.  
  69.  rexx=rm;
  70.  output=bool;
  71.  Titel=NULL;
  72.  Pos=0;
  73.  for(i=0,CmdCount=0;i<strlen(rexx->rm_Args[0]);i++)
  74.   {
  75.    c=rexx->rm_Args[0][i];
  76.    if(c==' ')
  77.     {
  78.      Command[CmdCount++][Pos]=0x00;
  79.      Pos=0;
  80.      if(CmdCount>9) break;
  81.     }
  82.    else
  83.     {
  84.      if(Pos<49) Command[CmdCount][Pos++]=toupper(c);
  85.     }
  86.   }
  87.  Command[CmdCount++][Pos]=0x00;
  88.  for(i=CmdCount;i<10;i++) *Command[i]=0;
  89.  Res1=0;
  90.  Res2=0;
  91.  if(!(strncmp(&Command[0],"INFO",4)))
  92.   {
  93.    ShowInformation(FALSE);
  94.   }
  95.  if(!(strncmp(&Command[0],"SAVEPREFS",9)))
  96.   {
  97.    PrefsOK=1;
  98.    CopyMem(&Einstellungen,Prefs,sizeof(struct Einstellungen));
  99.   }
  100.  if(!(strncmp(&Command[0],"LOADPREFS",9)))
  101.   {
  102.    if(PrefsOK==1)
  103.     {
  104.      CopyMem(Prefs,&Einstellungen,sizeof(struct Einstellungen));
  105.      ZeigeEinstellungen(TRUE);
  106.     }
  107.    else
  108.     {
  109.      OW(60,"loadprefs");
  110.      RW("FEHLER: Einstellungen wurden vorher nicht\n");
  111.      RW("        mit \"saveprefs\" gesichert.");
  112.     }
  113.   }
  114.  else if(!(strncmp(&Command[0],"ONLINE",6)))
  115.   {
  116.    if(Online==FALSE)
  117.     {
  118.      XLine(TRUE);
  119.     }
  120.   }
  121.  else if(!(strncmp(&Command[0],"OFFLINE",7)))
  122.   {
  123.    if(Online==TRUE)
  124.     {
  125.      XLine(FALSE);
  126.     }
  127.   }
  128.  else if(!(strncmp(&Command[0],"VERSION",7)))
  129.   {
  130.    OW(50,"version");
  131.    RW(Copyright[0]);
  132.    RW("\n");
  133.   }
  134.  else if(!(strncmp(&Command[0],"PCWRITEFILE",11)))
  135.   {
  136.    if(Online!=FALSE)
  137.     {
  138.      if(!(*Command[1]==0))
  139.       {
  140.        fh=Open(&Command[1],MODE_OLDFILE);
  141.        if(fh!=NULL)
  142.         {
  143.          SendeDatei(fh);
  144.          Close(fh);
  145.         }
  146.        else
  147.         {
  148.          Res1=10;
  149.          Res2=1;
  150.          OW(60,"pcwritefile");
  151.          RW("FEHLER: Die angegebene Datei konnte nicht\n");
  152.          RW("        geöffnet werden.\n");
  153.         }
  154.       }
  155.      else
  156.       {
  157.        Res1=10;
  158.        Res2=1;
  159.        OW(60,"pcwritefile");
  160.        RW("FEHLER: Fehlendes Argument.\n");
  161.        RW("        Syntax: pcwritefile [Dateiname]\n");
  162.       }
  163.     }
  164.    else
  165.     {
  166.      OW(60,"pcwritefile");
  167.      RW("FEHLER: Zum Übertragen muß ATKeyboard auf\n");
  168.      RW("        \"Online\" gesetzt sein.\n");
  169.     }
  170.   }
  171.  else if(!(strncmp(&Command[0],"SENDCLIPBOARD",13)))
  172.   {
  173.    if(Online!=FALSE)
  174.     {
  175.      if(ClipDev==0)
  176.       {
  177.        SendeClip();
  178.       }
  179.      else
  180.       {
  181.        OW(60,"sendclipboard");
  182.        RW("FEHLER: Clipboard-Device konnte beim Start von");
  183.        RW("       ATKeyboard nicht geladen werden!");
  184.       }
  185.     }
  186.    else
  187.     {
  188.      OW(60,"sendclipboard");
  189.      RW("FEHLER: Zum Übertragen muß ATKeyboard auf\n");
  190.      RW("        \"Online\" gesetzt sein.\n");
  191.     }
  192.   }
  193.  else if(!(strncmp(&Command[0],"GETVERSION",10)))
  194.    Res1=ATKeyboardVersion;
  195.  else if(!(strncmp(&Command[0],"GETREVISION",11)))
  196.    Res1=ATKeyboardRevision;
  197.  else if(!(strncmp(&Command[0],"GETSPEED",8)))
  198.    Res1=Einstellungen.Uebertragungsrate;
  199.  else if(!(strncmp(&Command[0],"GETPRI",6)))
  200.    Res1=Einstellungen.Prioritaet;
  201.  else if(!(strncmp(&Command[0],"LOCK",4)))
  202.    ARexxLock=1;
  203.  else if(!(strncmp(&Command[0],"UNLOCK",6)))
  204.    ARexxLock=0;
  205.  else if(!(strncmp(&Command[0],"MENULOCK",8)))
  206.   {
  207.    if(MLTitel==NULL)
  208.     {
  209.      MLTitel=WindowPtr->Title;
  210.      WindowPtr->Flags |= RMBTRAP;
  211.      SetWindowTitles(WindowPtr,"ATKeyboard - ARexx Menüsperre aktiv!",-1L);
  212.     }
  213.   }
  214.  else if(!(strncmp(&Command[0],"MENUUNLOCK",10)))
  215.   { 
  216.    WindowPtr->Flags &= xRMBTRAP;
  217.    if(MLTitel!=NULL)
  218.     {
  219.      SetWindowTitles(WindowPtr,MLTitel,-1L);
  220.      MLTitel=NULL;
  221.     }
  222.   }
  223.  else if(!(strncmp(&Command[0],"PCWRITE",7)))
  224.   {
  225.    if(Online==TRUE)
  226.     {
  227.      if(!(*Command[1]==0))
  228.       {
  229.        i=atol(&Command[1]);
  230.        if((i<0)||(i>255))
  231.         {
  232.          Res1=10;
  233.          Res2=1;
  234.          OW(60,"pcwrite");
  235.          RW("FEHLER: Falscher Code.\n");
  236.          RW("        Code muß im Bereich von 0 bis 255 liegen.\n");
  237.         }
  238.        else
  239.         {
  240.          Taste(i,0);
  241.         }
  242.       }
  243.      else
  244.       {
  245.        Res1=10;
  246.        Res2=1;
  247.        OW(60,"pcwrite");
  248.        RW("FEHLER: Fehlendes Argument.\n");
  249.        RW("        Syntax: pcwrite [Rawkey-Code]\n");
  250.       }
  251.     }
  252.   }
  253.  else if(!(strncmp(&Command[0],"LPT1",4)))
  254.   {
  255.    if(!(*Command[1]==0))
  256.     {
  257.      if(!(strncmp(&Command[1],"ON",2)))
  258.       {
  259.        LPT1=TRUE;
  260.        KontrolliereLPT1();  
  261.       }
  262.      else if(!(strncmp(&Command[1],"OFF",3)))
  263.       {
  264.        LPT1=FALSE;
  265.        KontrolliereLPT1();  
  266.       }
  267.      else if(!(strncmp(&Command[1],"RESET",5)))
  268.       {
  269.        Druckerreset();
  270.       }
  271.      else if(!(strncmp(&Command[1],"INFO",4)))
  272.       {
  273.        if(LPT1==TRUE)
  274.         {
  275.          OW(80,"LPT1");
  276.          sprintf(&buffer,"%8ld",transfer);
  277.          RW("Transfer:  "); RW(&buffer);
  278.          RW(" Bytes\nCache:     "); RW(CacheStat[Cache]);
  279.          RW("\nPapier:    "); RW(PapierStat[Papier]);
  280.          RW("\nDrucker:   "); RW(DruckerStat[Drucker]); RW("\n");
  281.         }
  282.        else
  283.         {
  284.          OW(50,"LPT1");
  285.          RW("Die LPT1-Verwaltung ist ausgeschaltet.\n");
  286.         }
  287.       }
  288.      else
  289.       {
  290.        OW(60,"LPT1");
  291.        RW("FEHLER: Falsches Argument.\n");
  292.        RW("        Syntax: LPT1 {on|off|reset|info}\n");
  293.       }
  294.     }
  295.    else
  296.     {
  297.      OW(50,"LPT1");
  298.      if(LPT1==TRUE)
  299.       {
  300.        RW("Die LPT1-Verwaltung ist eingeschaltet.\n");
  301.       }
  302.      else
  303.       {
  304.        RW("Die LPT1-Verwaltung ist ausgeschaltet.\n");
  305.       }
  306.     }
  307.   }
  308.  else if(!(strncmp(&Command[0],"TIMESERV",8)))
  309.   {
  310.    if(!(*Command[1]==0))
  311.     {
  312.      if(!(strncmp(&Command[1],"ON",2)))
  313.       {
  314.        Service=TRUE;
  315.        KontrolliereService();
  316.       }
  317.      else if(!(strncmp(&Command[1],"OFF",3)))
  318.       {
  319.        Service=FALSE;
  320.        KontrolliereService();
  321.       }
  322.      else if(!(strncmp(&Command[1],"INFO",4)))
  323.       {
  324.        OW(50,"timeserv");
  325.        if(Service==TRUE)
  326.          RW("TimeService ist eingeschaltet.");
  327.        else
  328.          RW("TimeService ist ausgeschaltet.");
  329.       }
  330.     }
  331.    else
  332.     {
  333.      OW(60,"timeserv");
  334.      RW("FEHLER: Falsches Argument.\n");
  335.      RW("        Syntax: timeserv [on|off|info]\n");
  336.     }
  337.   }
  338.  else if(!(strncmp(&Command[0],"CLOCK",5)))
  339.   {
  340.    if(!(*Command[1]==0))
  341.     {
  342.      if(!(strncmp(&Command[1],"ON",2)))
  343.       {
  344.        Clock=TRUE;
  345.        KontrolliereUhr();
  346.       }
  347.      else if(!(strncmp(&Command[1],"OFF",3)))
  348.       {
  349.        Clock=FALSE;
  350.        KontrolliereUhr();
  351.       }
  352.     }
  353.    else
  354.     {
  355.      OW(60,"clock");
  356.      RW("FEHLER: Falsches Argument.\n");
  357.      RW("        Syntax: clock [on|off]\n");
  358.     }
  359.   }
  360.  else if(!(strncmp(&Command[0],"KEYFILTER",9)))
  361.   {
  362.    if(!(*Command[1]==0))
  363.     {
  364.      if(!(strncmp(&Command[1],"ON",2)))
  365.        Einstellungen.Tastenfilter=YES;
  366.      if(!(strncmp(&Command[1],"OFF",2)))
  367.        Einstellungen.Tastenfilter=NO;
  368.      ZeigeEinstellungen(TRUE);
  369.     }
  370.    else
  371.     {
  372.      OW(60,"keyfilter");
  373.      RW("FEHLER: Falsches Argument.\n");
  374.      RW("        Syntax: keyfilter [on|off]\n");
  375.     }
  376.   }
  377.  else if(!(strncmp(&Command[0],"KEYREPEAT",9)))
  378.   {
  379.    if(!(*Command[1]==0))
  380.     {
  381.      if(!(strncmp(&Command[1],"ON",2)))
  382.        Einstellungen.Tastenwiederholung=YES;
  383.      if(!(strncmp(&Command[1],"OFF",2)))
  384.        Einstellungen.Tastenwiederholung=NO;
  385.      ZeigeEinstellungen(TRUE);
  386.     }
  387.    else
  388.     {
  389.      OW(60,"keyrepeat");
  390.      RW("FEHLER: Falsches Argument.\n");
  391.      RW("        Syntax: keyrepeat [on|off]\n");
  392.     }
  393.   }
  394.  else if(!(strncmp(&Command[0],"KEYUP",5)))
  395.   {
  396.    if(!(*Command[1]==0))
  397.     {
  398.      if(!(strncmp(&Command[1],"ON",2)))
  399.        Einstellungen.Tastenruecknahme=YES;
  400.      if(!(strncmp(&Command[1],"OFF",2)))
  401.        Einstellungen.Tastenruecknahme=NO;
  402.      ZeigeEinstellungen(TRUE);
  403.     }
  404.    else
  405.     {
  406.      OW(60,"keyup");
  407.      RW("FEHLER: Falsches Argument.\n");
  408.      RW("        Syntax: keyup [on|off]\n");
  409.     }
  410.   }
  411.  else if(!(strncmp(&Command[0],"INTWAIT",7)))
  412.   {
  413.    if(!(*Command[1]==0))
  414.     {
  415.      if(!(strncmp(&Command[1],"ON",2)))
  416.        Einstellungen.WarteAufInt=YES;
  417.      if(!(strncmp(&Command[1],"OFF",2)))
  418.        Einstellungen.WarteAufInt=NO;
  419.      ZeigeEinstellungen(TRUE);
  420.     }
  421.    else
  422.     {
  423.      OW(60,"intwait");
  424.      RW("FEHLER: Falsches Argument.\n");
  425.      RW("        Syntax: intwait [on|off]\n");
  426.     }
  427.   }
  428.  else if(!(strncmp(&Command[0],"SETSPEED",8)))
  429.   {
  430.    if(!(*Command[1]==0))
  431.     {
  432.      i=atol(&Command[1]);
  433.      if(i>150) i=150;
  434.      if(i<0) i=0;
  435.      Einstellungen.Uebertragungsrate=i;
  436.     }
  437.    else
  438.     {
  439.      OW(60,"setspeed");
  440.      RW("FEHLER: Falsches Argument.\n");
  441.      RW("        Syntax: setspeed [0..150]\n");
  442.     }
  443.   }
  444.  else if(!(strncmp(&Command[0],"SETPRI",6)))
  445.   {
  446.    if(!(*Command[1]==0))
  447.     {
  448.      i=atol(&Command[1]);
  449.      if(i>127) i=127;
  450.      if(i<-128) i=-128;
  451.      Einstellungen.Prioritaet=i;
  452.      SetTaskPri(MainTask,i);
  453.     }
  454.    else
  455.     {
  456.      OW(60,"setpri");
  457.      RW("FEHLER: Falsches Argument.\n");
  458.      RW("        Syntax: setpri [-128..127]\n");
  459.     }
  460.   }
  461.  else if(!(strncmp(&Command[0],"BLANKER",7)))
  462.   {
  463.    if(!(*Command[1]==0))
  464.     {
  465.      if(!(strncmp(&Command[1],"ON",2)))
  466.       {
  467.        Schoner=TRUE;
  468.        KontrolliereSchoner();
  469.       }
  470.      else if(!(strncmp(&Command[1],"OFF",3)))
  471.       {
  472.        Schoner=FALSE;
  473.        KontrolliereSchoner();
  474.       }
  475.      else
  476.       {
  477.        OW(60,"blanker");
  478.        RW("FEHLER: Falsches Argument.\n");
  479.        RW("        Syntax: blanker {on|off}\n");
  480.       }
  481.     } 
  482.    else
  483.     {
  484.      if(Schoner==TRUE)
  485.       {
  486.        RW("Der Schoner ist eingeschaltet.\n");
  487.       }
  488.      else
  489.       {
  490.        RW("Der Schoner ist ausgeschaltet.\n");
  491.       }
  492.     }
  493.   }
  494.  else if(!(strncmp(&Command[0],"PLAYER",6)))
  495.   {
  496.    if(!(*Command[1]==0))
  497.     {
  498.      bool=TRUE;
  499.      if(!(strncmp(&Command[1],"PLAY",4)))
  500.        bool=UtilityQuiet(HiFiPort,1001);
  501.      else if(!(strncmp(&Command[1],"STOP",4)))
  502.        bool=UtilityQuiet(HiFiPort,1002);
  503.      else if(!(strncmp(&Command[1],"FIRST",5)))
  504.        bool=UtilityQuiet(HiFiPort,1003);
  505.      else if(!(strncmp(&Command[1],"LAST",4)))
  506.        bool=UtilityQuiet(HiFiPort,1004);
  507.      else if(!(strncmp(&Command[1],"NEXT",4)))
  508.        bool=UtilityQuiet(HiFiPort,1005);
  509.      else if(!(strncmp(&Command[1],"PREV",4)))
  510.        bool=UtilityQuiet(HiFiPort,1006);
  511.      else if(!(strncmp(&Command[1],"RND",3)))
  512.        bool=UtilityQuiet(HiFiPort,1500);
  513.      else if(!(strncmp(&Command[1],"QUIT",4)))
  514.        bool=UtilityQuiet(HiFiPort,UTILITY_QUIT);
  515.      else if(!(strncmp(&Command[1],"VOL+",4)))
  516.        bool=UtilityQuiet(HiFiPort,1013);
  517.      else if(!(strncmp(&Command[1],"VOL-",4)))
  518.        bool=UtilityQuiet(HiFiPort,1014);
  519.      else if(!(strncmp(&Command[1],"LOAD",4)))
  520.        bool=UtilityQuiet(HiFiPort,1008);
  521.      else if(!(strncmp(&Command[1],"SAVE",4)))
  522.        bool=UtilityQuiet(HiFiPort,1009);
  523.      else if(!(strncmp(&Command[1],"EDIT",4)))
  524.        bool=UtilityQuiet(HiFiPort,1007);
  525.      else if(!(strncmp(&Command[1],"DISPLAY",7)))
  526.        bool=UtilityQuiet(HiFiPort,1012);
  527.      else
  528.       {
  529.        Res1=10;
  530.        Res2=1;
  531.        OW(70,"player");
  532.        RW("FEHLER: Unbekanntes Argument.\n");
  533.        RW("        Argumente: play stop first last next prev\n");
  534.        RW("                   vol+ vol- rnd   edit load save\n");
  535.        RW("                   display\n");
  536.       }
  537.      if(bool==FALSE)
  538.       {
  539.        Res1=10;
  540.        Res2=1;
  541.        OW(60,"player");
  542.        RW("FEHLER: HiFi-Player ist nicht aktiv.\n");
  543.        RW("        Starten Sie zuerst das Programm!\n");
  544.       }
  545.     }
  546.    else
  547.     {
  548.      Res1=10;
  549.      Res2=1;
  550.      OW(70,"player");
  551.      RW("FEHLER: Falsches Argument.\n");
  552.      RW("        Argumente: play stop first last next prev\n");
  553.      RW("                   vol+ vol- rnd   edit load save\n");
  554.      RW("                   display\n");
  555.     }
  556.   }
  557.  else if(!(strncmp(&Command[0],"UTILITYQUIET",12)))
  558.   {
  559.    if(!(*Command[1]==0))
  560.     {
  561.      if((*Command[2]==0))
  562.       {
  563.        UtilityQuiet(&Command[1],UTILITY_CALL);
  564.       }
  565.      else
  566.       {
  567.        UtilityQuiet(&Command[1],atol(&Command[2]));
  568.       }
  569.     }
  570.    else
  571.     {
  572.      Res1=10;
  573.      Res2=1;
  574.      OW(60,"utilityquiet");
  575.      RW("FEHLER: Falsches Argument.\n");
  576.      RW("        Syntax: utility [Portname] {Kommando}\n");
  577.     }
  578.   }
  579.  else if(!(strncmp(&Command[0],"UTILITY",7)))
  580.   {
  581.    if(!(*Command[1]==0))
  582.     {
  583.      if((*Command[2]==0))
  584.       {
  585.        CallUtility(&Command[1]);
  586.       }
  587.      else
  588.       {
  589.        Utility(&Command[1],atol(&Command[2]));
  590.       }
  591.     }
  592.    else
  593.     {
  594.      Res1=10;
  595.      Res2=1;
  596.      OW(60,"utility");
  597.      RW("FEHLER: Falsches Argument.\n");
  598.      RW("        Syntax: utility [Portname] {Kommando}\n");
  599.     }
  600.   }
  601.  else if(!(strncmp(&Command[0],"DATACACHE",9)))
  602.   {
  603.    if(KickstartVersion>=36)
  604.     {
  605.      if(SysBase->AttnFlags & AFF_68030)
  606.       {
  607.        if(!(*Command[1]==0))
  608.         {
  609.          if(!(strncmp(&Command[1],"ON",2)))
  610.           {
  611.            CacheControl(CACRF_EnableD,CACRF_EnableD|CACRF_FreezeD);
  612.           }
  613.          else if(!(strncmp(&Command[1],"OFF",3)))
  614.           {
  615.            CacheControl(CACRF_FreezeD,CACRF_EnableD|CACRF_FreezeD);
  616.           }
  617.          else
  618.           {
  619.            Res1=10;
  620.            Res2=1;
  621.            OW(60,"datacache");
  622.            RW("FEHLER: Falsches Argument.\n");
  623.            RW("        Syntax: datacache {on|off}\n");
  624.           }
  625.         }
  626.        else
  627.         {
  628.          i=CacheControl(0,0);
  629.          t="Der Datencache ist ausgeschaltet";
  630.          if(i & CACRF_EnableD) t="Der Datencache ist eingeschaltet";
  631.          if((i & CACRF_EnableD)&&(i & CACRF_DBE)) t="Der Datencache ist im Burst-Modus";
  632.          OW(60,"datacache");
  633.          RW("Aktueller Status des Datencaches:\n   ");
  634.          RW(t);
  635.          RW("\n");
  636.         }
  637.       }
  638.      else
  639.       {
  640.        Res1=10;
  641.        Res2=1;
  642.        OW(60,"datacache");
  643.        RW("FEHLER: \"datacache\" ist erst bei 68030-Systemen verfügbar!\n");
  644.       }
  645.     }
  646.    else
  647.     {
  648.      Res1=10;
  649.      Res2=1;
  650.      OW(60,"datacache");
  651.      RW("FEHLER: \"datacache\" ist erst ab Kickstart\n");
  652.      RW("        Version 2.0 verfügbar!\n");
  653.     }
  654.   }
  655.  else if(!(strncmp(&Command[0],"HELP",4)))
  656.   {
  657.    OW(170,"help");
  658.    RW("ATKeyboard hält für Sie folgende Befehle bereit:\n");
  659.    RW(" - help\n");
  660.    RW(" - info\n");
  661.    RW(" - quit\n");
  662.    RW(" - online\n");
  663.    RW(" - offline\n");
  664.    RW(" - version\n");
  665.    RW(" - LPT1 {on|off|reset|info}\n");
  666.    RW(" - blanker {on|off}\n");
  667.    RW(" - datacache {on|off}\n");
  668.    RW(" - pcwrite [Rawkey-Code]\n");
  669.    RW(" - pcwritefile [Dateiname]\n");
  670.    RW(" - utility [Portname]\n");
  671.    RW(" - player [play|stop|first|last|next|prev|rnd\n");
  672.    RW("           load|save|edit|vol+|vol-|display]\n");
  673.   }
  674.  else if(!(strncmp(&Command[0],"QUIT",4)))
  675.   {
  676.    rexx->rm_Result1=0;
  677.    rexx->rm_Result2=0;
  678.    ReplyMsg(rexx);
  679.    CloseAll();
  680.   }
  681.  else
  682.   {
  683.    Res1=10;
  684.    Res2=1;
  685.    OW(50,"?");
  686.    RW("FEHLER: Unbekanntes Kommando. Hilfe mit \"help\".\n");
  687.   }
  688.  rexx->rm_Result1=Res1;
  689.  rexx->rm_Result2=Res2;
  690.  ReplyMsg(rexx);
  691.  if(RWindow!=NULL)
  692.   {
  693.    RW("\n<< Taste >>\n");
  694.    Read(RWindow,&c,1);
  695.    Close(RWindow);
  696.    RWindow=NULL;
  697.   }
  698.  if(Titel!=NULL)
  699.   {
  700.    SetMenuStrip(WindowPtr,&Menu1);
  701.    SetWindowTitles(WindowPtr,Titel,TitelText);
  702.   }
  703. }
  704.  
  705.  
  706. /* Text in ARexx-Fenster schreiben */
  707. VOID RW(text)
  708.  UBYTE *text;
  709. {
  710.  if(RWindow)
  711.   {
  712.    Write(RWindow,text,strlen(text));
  713.   }
  714.  else
  715.   {
  716.    if(rexx->rm_Stdout) Write(rexx->rm_Stdout,text,strlen(text));
  717.   }
  718. }
  719.  
  720.  
  721. /* ARexx-Ausgabe öffnen */
  722. VOID OW(ySize,cmd)
  723.  LONG ySize;
  724.  UBYTE *cmd;
  725. {
  726.  REGISTER UWORD top;
  727.  REGISTER UBYTE c;
  728.  UBYTE          buffer[70];
  729.  
  730.  RWindow=NULL;
  731.  top=(200-ySize)/2;
  732.  if((output==FALSE)||(rexx->rm_Stdout==NULL))
  733.   {
  734.    ClearMenuStrip(WindowPtr);
  735.    Titel=WindowPtr->Title;
  736.    sprintf(&ARexxTitel,"ATKeyboard - ARexx \"%s\"",cmd);
  737.    SetWindowTitles(WindowPtr,&ARexxTitel,TitelText);
  738.    if(KickstartVersion>=36) c='/'; else c=0x00;
  739.    sprintf(&buffer,"CON:75/%ld/450/%ld/ATKeyboard - ARexx \"%s\"%cCLOSE",top,ySize,cmd,c);
  740.    RWindow=Open(&buffer,MODE_READWRITE);
  741.   }
  742. }
  743.  
  744.  
  745. /* ASCII-Zeichen an PC senden */
  746. #define NORMAL 0
  747. #define SHIFT (1L<<1)
  748. #define BIT7  (1L<<7)
  749.  
  750. struct Tabelle
  751. {
  752.  UBYTE Zeichen;
  753.  UBYTE RawCode;
  754.  UBYTE Flags;
  755. };
  756.  
  757. struct Tabelle T[]=
  758. {
  759.  {0x0A,0x44,NORMAL},
  760.  {' ',0x40,NORMAL},
  761.  {'1',0x01,NORMAL}, {'2',0x02,NORMAL}, {'3',0x03,NORMAL}, {'4',0x04,NORMAL},
  762.  {'5',0x05,NORMAL}, {'6',0x06,NORMAL}, {'7',0x07,NORMAL}, {'8',0x08,NORMAL},
  763.  {'9',0x09,NORMAL}, {'0',0x0A,NORMAL}, {'ß',0x0B,NORMAL}, {'\\',0x0D,NORMAL},
  764.  {'q',0x10,NORMAL}, {'w',0x11,NORMAL}, {'e',0x12,NORMAL}, {'r',0x13,NORMAL},
  765.  {'t',0x14,NORMAL}, {'z',0x15,NORMAL}, {'u',0x16,NORMAL}, {'i',0x17,NORMAL},
  766.  {'o',0x18,NORMAL}, {'p',0x19,NORMAL}, {'ü',0x1A,NORMAL}, {'+',0x1B,NORMAL},
  767.  {'a',0x20,NORMAL}, {'s',0x21,NORMAL}, {'d',0x22,NORMAL}, {'f',0x23,NORMAL},
  768.  {'g',0x24,NORMAL}, {'h',0x25,NORMAL}, {'j',0x26,NORMAL}, {'k',0x27,NORMAL},
  769.  {'l',0x28,NORMAL}, {'ö',0x29,NORMAL}, {'ä',0x2A,NORMAL}, {'#',0x2B,NORMAL},
  770.  {'<',0x30,NORMAL}, {'y',0x31,NORMAL}, {'x',0x32,NORMAL}, {'c',0x33,NORMAL},
  771.  {'v',0x34,NORMAL}, {'b',0x35,NORMAL}, {'n',0x36,NORMAL}, {'m',0x37,NORMAL},
  772.  {',',0x38,NORMAL}, {'.',0x39,NORMAL}, {'-',0x3A,NORMAL},
  773.  
  774.  {'!',0x01,SHIFT},  {'\"',0x02,SHIFT}, {'§',0x03,SHIFT},  {'$',0x04,SHIFT},
  775.  {'%',0x05,SHIFT},  {'&',0x06,SHIFT},  {'/',0x07,SHIFT},  {'(',0x08,SHIFT},
  776.  {')',0x09,SHIFT},  {'=',0x0A,SHIFT},  {'?',0x0B,SHIFT},  {'|',0x0D,SHIFT},
  777.  {'Q',0x10,SHIFT},  {'W',0x11,SHIFT},  {'E',0x12,SHIFT},  {'R',0x13,SHIFT},
  778.  {'T',0x14,SHIFT},  {'Z',0x15,SHIFT},  {'U',0x16,SHIFT},  {'I',0x17,SHIFT},
  779.  {'O',0x18,SHIFT},  {'P',0x19,SHIFT},  {'Ü',0x1A,SHIFT},  {'*',0x1B,SHIFT},
  780.  {'A',0x20,SHIFT},  {'S',0x21,SHIFT},  {'D',0x22,SHIFT},  {'F',0x23,SHIFT},
  781.  {'G',0x24,SHIFT},  {'H',0x25,SHIFT},  {'J',0x26,SHIFT},  {'K',0x27,SHIFT},
  782.  {'L',0x28,SHIFT},  {'Ö',0x29,SHIFT},  {'Ä',0x2A,SHIFT},  {'^',0x2B,SHIFT},
  783.  {'>',0x30,SHIFT},  {'Y',0x31,SHIFT},  {'X',0x32,SHIFT},  {'C',0x33,SHIFT},
  784.  {'V',0x34,SHIFT},  {'B',0x35,SHIFT},  {'N',0x36,SHIFT},  {'M',0x37,SHIFT},
  785.  {';',0x38,SHIFT},  {':',0x39,SHIFT},  {'_',0x3A,SHIFT},
  786.  {0xFF,0xFF,0xFF}
  787. };
  788.  
  789. VOID SendeZeichen(chr)
  790.  UBYTE chr;
  791. {
  792.  REGISTER UBYTE Flags;
  793.  REGISTER UBYTE RawCode;
  794.  REGISTER WORD  i;
  795.  
  796.  switch(chr)
  797.   {
  798.    case '{':
  799.      Tastenkombination(&MKAuf);
  800.     break;
  801.    case '}':
  802.      Tastenkombination(&MKZu);
  803.     break;
  804.    case '[':
  805.      Tastenkombination(&IKAuf);
  806.     break;
  807.    case ']':
  808.      Tastenkombination(&IKZu);
  809.     break;
  810.    default:
  811.      RawCode=10000;
  812.      for(i=0;i<10000;i++)
  813.       {
  814.        if(T[i].Zeichen==chr)
  815.         {
  816.          RawCode=T[i].RawCode;
  817.          Flags=T[i].Flags;
  818.          i=10000;
  819.         }
  820.        else if(T[i].Flags==0xFF) i=10000;
  821.       }
  822.      if(RawCode!=10000)
  823.       {
  824.        if(Flags & SHIFT) Taste(0x60,0);
  825.        Taste(RawCode,0);
  826.        Taste(RawCode|BIT7,0);
  827.        if(Flags & SHIFT) Taste(0x60|BIT7,0);
  828.       }
  829.     break;
  830.   }
  831. }
  832.  
  833.  
  834. /* Zeichen aus ASCII-Datei an PC senden */
  835. VOID SendeDatei(fh)
  836.  struct FileHandle *fh;
  837. {
  838.  register struct Window  *win;
  839.  register struct MsgPort *user;
  840.  struct IntuiMessage     *msg;
  841.  REGISTER ULONG           i,j,len,Pos;
  842.  UBYTE                    Buffer[10];
  843.  
  844.  ClearMenuStrip(WindowPtr);
  845.  Titel=WindowPtr->Title;
  846.  
  847.  win=CreateStdWindow("Übertragung",75,100,150,24+BorderHeight(),CLOSEWINDOW|GADGETUP|VANILLAKEY,
  848.                 WINDOWCLOSE|WINDOWDEPTH|WINDOWDRAG|ACTIVATE|GIMMEZEROZERO);
  849.  if(win!=NULL)
  850.   {
  851.    SetFont(win->RPort,GetOpalFont());
  852.    CreateBoolGadget(win,10,5,120,12,"Stop!");
  853.    user=win->UserPort;
  854.    j=0;
  855.    len=Seek(fh,0,OFFSET_END);
  856.    len=Seek(fh,0,OFFSET_BEGINNING);
  857.    do
  858.     {
  859.      sprintf(&ARexxTitel,
  860.              "ATKeyboard - [Übertragung -> %ld%%, %ld Bytes]",
  861.              (DivU32(MulU32(j,100),len)),j);
  862.      SetWindowTitles(WindowPtr,&ARexxTitel,TitelText);
  863.      i=Read(fh,&Buffer,10);
  864.      for(Pos=0;Pos<i;Pos++)
  865.       {
  866.        SendeZeichen(Buffer[Pos]);
  867.        j++;
  868.       }
  869.      msg=GetMsg(user);
  870.      if(msg!=NULL)
  871.       {
  872.        ReplyMsg(msg);
  873.        i=0;
  874.       }
  875.     }
  876.    while(i!=0);
  877.    Close(fh);
  878.    DeleteStdWindow(win);
  879.   }
  880.  else
  881.   {
  882.    Requester("Kein Speicher für Stop-Fenster","","Okay",NULL);
  883.   }
  884.  SetMenuStrip(WindowPtr,&Menu1);
  885.  SetWindowTitles(WindowPtr,Titel,TitelText);
  886. }
  887.  
  888.  
  889. /* Clip-Header lesen */
  890. LONG TeilKopfLesen()
  891. {
  892.  UBYTE  KopfDaten[8];
  893.  LONG  *NettoDaten;
  894.  
  895.  ClipReq->io_Data=&KopfDaten;
  896.  ClipReq->io_Length=8;
  897.  ClipReq->io_Command=CMD_READ;
  898.  DoIO(ClipReq);
  899.  NettoDaten=&KopfDaten[4];
  900.  return(*NettoDaten);
  901. }
  902.  
  903.  
  904. /* Testen, ob überhaupt ein Clip vorliegt */
  905. BOOL ClipVorhanden()
  906. {
  907.  BOOL ClipOkay;
  908.  
  909.  if(CheckIO(ClipReq))
  910.   {
  911.    ClipOkay=(ClipReq->io_ClipID >= 0);
  912.    Remove(ClipReq);
  913.   }
  914.  else
  915.   {
  916.    Delay(20);
  917.  
  918.    if(CheckIO(ClipReq))
  919.     {
  920.      ClipOkay=(ClipReq->io_ClipID >= 0);
  921.      Remove(ClipReq);
  922.     }
  923.    else
  924.     {
  925.      AbortIO(ClipReq);
  926.      ClipOkay=FALSE;
  927.     }
  928.   }
  929.  return(ClipOkay);
  930. }
  931.  
  932.  
  933. /* Clip-Kopf lesen */
  934. LONG ClipKopfLesen()
  935. {
  936.  UBYTE KopfDaten[12];
  937.  
  938.  ClipReq->io_ClipID=0;
  939.  ClipReq->io_Command=CMD_READ;
  940.  ClipReq->io_Offset=0;
  941.  ClipReq->io_Data=&KopfDaten;
  942.  ClipReq->io_Length=12;
  943.  SendIO(ClipReq);
  944.  
  945.  if(ClipVorhanden())
  946.    return(TeilKopfLesen());
  947.  else
  948.    return(NULL);
  949. }  
  950.  
  951.  
  952. /* Clip aus Clipboard an PC senden */
  953. VOID SendeClip()
  954. {
  955.  register struct Window  *win;
  956.  register struct MsgPort *user;
  957.  struct IntuiMessage     *msg;
  958.  REGISTER ULONG           j,len,Pos;
  959.  REGISTER BOOL            ende;
  960.  UBYTE                    Buffer[16];
  961.  
  962.  ClipReq->io_Length=ClipKopfLesen();
  963.  if(ClipReq->io_Length)
  964.   {
  965.    ClearMenuStrip(WindowPtr);
  966.    Titel=WindowPtr->Title;
  967.  
  968.    win=CreateStdWindow("Übertragung",75,100,150,24+BorderHeight(),CLOSEWINDOW|GADGETUP|VANILLAKEY,
  969.                 WINDOWCLOSE|WINDOWDEPTH|WINDOWDRAG|ACTIVATE|GIMMEZEROZERO);
  970.    if(win!=NULL)
  971.     {
  972.      SetFont(win->RPort,GetOpalFont());
  973.      CreateBoolGadget(win,10,5,120,12,"Stop!");
  974.      user=win->UserPort;
  975.      ClipReq->io_Data=&Buffer;
  976.      ClipReq->io_Length=16;
  977.      DoIO(ClipReq);
  978.      ende=FALSE; j=0;
  979.      while((ClipReq->io_Actual>0)&&(ende==FALSE))
  980.       {
  981.        sprintf(&ARexxTitel,
  982.                "ATKeyboard - [Übertragung -> %ld Bytes]",j);
  983.        SetWindowTitles(WindowPtr,&ARexxTitel,TitelText);
  984.        for(Pos=0;Pos<ClipReq->io_Actual;Pos++)
  985.         {
  986.          SendeZeichen(Buffer[Pos]);
  987.          j++;
  988.         }
  989.        msg=GetMsg(user);
  990.        if(msg!=NULL)
  991.         {
  992.          ReplyMsg(msg);
  993.          ende=TRUE;
  994.         }
  995.        ClipReq->io_Data=&Buffer;
  996.        ClipReq->io_Length=16;
  997.        DoIO(ClipReq);
  998.       }
  999.      DeleteStdWindow(win);
  1000.     }
  1001.    else
  1002.     {
  1003.      Requester("Kein Speicher für Stop-Fenster","","Okay",NULL);
  1004.     }
  1005.    ClipReq->io_Data=NULL;
  1006.    ClipReq->io_Length=1024;
  1007.    while(ClipReq->io_Actual>0)
  1008.      DoIO(ClipReq);
  1009.    SetMenuStrip(WindowPtr,&Menu1);
  1010.    SetWindowTitles(WindowPtr,Titel,TitelText);
  1011.   }
  1012. }
  1013.  
  1014.